Checking property preservation of refining transformations for model-driven development

In Model-Driven Software Development, a software product is created through iteratively refined modelling. It is crucial that this process preserves certain desirable properties of the initial model. However, checking this is increasingly difficult as the models are increasingly more refined. We propose an incremental model checking technique to determine the preservation of safety and liveness properties in models of concurrent systems with respect to changes applied on individual processes, formalised as transformations of Labelled Transition Systems. The preservation check involves checking bisimilarity between transformed and new behaviour, and never involves reexploring unchanged behaviour. We prove its correctness and demonstrate its applicability

What to do Next? : Analysing and Optimising System Behaviour in Time

Fokkink, W.J. [Promotor]Pol, J.C. van de [Promotor

Solving scheduling problems by untimed model checking

In this paper, we show how scheduling problems can be modelled in untimed process algebra, by using special tick actions. A minimal-time trace leading to a particular action, is one that minimizes the number of tick steps. As a result, we can use any (timed or untimed) model checking tool to find shortest schedules. Instantiating this scheme t

Parallel algorithms for transitive reduction for weighted graphs

Abstract. We present a generalization of transitive reduction for weighted graphs and give scalable polynomial algorithms for computing it based on the Floyd-Warshall algorithm for finding shortest paths in graphs. We also show how the algorithms can be optimized for memory efficiency and effectively parallelized to improve the run time. As a consequence, the algorithms can be tuned for modern general purpose graphics processors. Our prototype implementations exhibit significant speedups of more than one order of magnitude compared to their sequential counterparts. Transitive reduction for weighted graphs was instigated by problems in reconstruction of genetic networks. The first experiments in that domain show also encouraging results both regarding run time and the quality of the reconstruction

Towards verified Java code generation from concurrent state machines

We present work in progress on, verified, transformation of a modeling language based on communicating concurrent state machines, SLCO, to Java. Some concurrency related challenges, related to atomicity and non-standard fairness issues, are pointed out. We discuss solutions based on Java synchronization concepts

Achieving Discrete Relative Timing with Untimed Process Algebra

For many systems, timing aspects are essential. Therefore, when modelling these systems, time should somehow be represented. In the past, many timed pro- cess algebras have been developed, using untimed pro- cess algebras as initial inspiration. In this paper, we take another approach, considering the possibility to model timing aspects with an untimed process algebra. The advantage is that the algebra itself does not need to be extended, and the available tools can be reused. In contrast to other work, where this approach has been looked at, we focus on ease of modelling, and single delay steps of varying sizes. We present the timing mechanism used, our approach, and some examples

Efficient property preservation checking of model refinements

In model-driven software development, models and model refinements are used to create software. To automatically generate correct software from abstract models by means of model refinement, desirable properties of the initial models must be preserved. We propose an explicit-state model checking technique to determine whether refinements are property preserving. We use networks of labelled transition systems (LTSs) to represent models with concurrent components, and formalise refinements as systems of LTS transformation rules. Property preservation checking involves determining how a rule system relates to an input network, and checking bisimilarity between behaviour subjected to transformation and the corresponding behaviour after transformation. In this way, one avoids generating the entire LTS of the new model. Experimental results demonstrate speedups of several orders of magnitude

Efficient on-the-fly computation of weak tau-confluence

The notion of tau-confluence provides a form of partial order reduction of Labelled Transition Systems (LTSs), by allowing to identify the tau-transitions whose execution does not alter the observable behaviour of the system. Several forms of tau-confluence adequate with branching bisimulation were studied in the literature, ranging from strong to weak ones according to the length of tau-transition sequences considered. Weak tau-confluence is more complex to compute than strong tau-confluence, but provides better LTS reductions. In this report, we aim at devising an efficient detection of weak tau-confluent transitions during an on-the-fly exploration of LTSs. To this purpose, we define and prove new encodings of several weak tau-confluence variants using alternation-free boolean equation systems (BESs), and we apply efficient local BES resolution algorithms to perform the detection. The resulting reduction module, developed within the CADP toolbox using the generic OPEN/CAESAR environment for LTS exploration, was experimented on numerous examples of large LTSs underlying communication protocols and distributed systems. These experiments assessed the efficiency of the reduction and allowed us to identify the best variants of weak tau-confluence that are useful in practice